home *** CD-ROM | disk | FTP | other *** search
/ Game Programming in C++ - Start to Finish / GameProgrammingS.iso / developer_install / CEGUISDK-0.4.1-VC6-STLport.exe / {app} / include / CEGUIWindowProperties.h < prev    next >
C/C++ Source or Header  |  2005-07-21  |  50KB  |  1,679 lines

  1. /************************************************************************
  2.     filename:     CEGUIWindowProperties.h
  3.     created:    5/7/2004
  4.     author:        Paul D Turner
  5.     
  6.     purpose:    Interface to available window base class properties
  7. *************************************************************************/
  8. /*************************************************************************
  9.     Crazy Eddie's GUI System (http://www.cegui.org.uk)
  10.     Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
  11.  
  12.     This library is free software; you can redistribute it and/or
  13.     modify it under the terms of the GNU Lesser General Public
  14.     License as published by the Free Software Foundation; either
  15.     version 2.1 of the License, or (at your option) any later version.
  16.  
  17.     This library is distributed in the hope that it will be useful,
  18.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20.     Lesser General Public License for more details.
  21.  
  22.     You should have received a copy of the GNU Lesser General Public
  23.     License along with this library; if not, write to the Free Software
  24.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25. *************************************************************************/
  26. #ifndef _CEGUIWindowProperties_h_
  27. #define _CEGUIWindowProperties_h_
  28.  
  29. #include "CEGUIProperty.h"
  30.  
  31.  
  32. // Start of CEGUI namespace section
  33. namespace CEGUI
  34. {
  35.  
  36. // Start of WindowProperties namespace section
  37. /*!
  38. \brief
  39.     Namespace containing all classes that make up the properties interface for the Window base class
  40. */
  41. namespace WindowProperties
  42. {
  43. /*!
  44. \brief
  45.     Property to access minimum window size.
  46.  
  47.     This property offers access to the minimum size setting for the window, using screen relative metrics.
  48.  
  49.     \par Usage:
  50.         - Name: RelativeMinSize
  51.         - Format: "w:[float] h:[float]".
  52.  
  53.     \par Where:
  54.         - w:[float]    specifies the minimum width as a floating point number.
  55.         - h:[float] specifies the minimum height as a floating point number.
  56. */
  57. class RelativeMinSize : public Property
  58. {
  59. public:
  60.     RelativeMinSize() : Property(
  61.         "RelativeMinSize",
  62.         "Property to get/set the minimum size for the Window.  Value is \"w:[float] h:[float]\" using relative metrics (this setting is relative to the display size).",
  63.         "w:0.000000 h:0.000000", false)
  64.     {}
  65.  
  66.     String    get(const PropertyReceiver* receiver) const;
  67.     void    set(PropertyReceiver* receiver, const String& value);
  68. };
  69.  
  70.  
  71. /*!
  72. \brief
  73.     Property to access maximum window size.
  74.  
  75.     This property offers access to the maximum size setting for the window, using screen relative metrics.
  76.  
  77.     \par Usage:
  78.         - Name: RelativeMaxSize
  79.         - Format: "w:[float] h:[float]".
  80.  
  81.     \par Where:
  82.         - w:[float]    specifies the maximum width as a floating point number.
  83.         - h:[float] specifies the maximum height as a floating point number.
  84. */
  85. class RelativeMaxSize : public Property
  86. {
  87. public:
  88.     RelativeMaxSize() : Property(
  89.         "RelativeMaxSize",
  90.         "Property to get/set the maximum size for the Window.  Value is \"w:[float] h:[float]\" using relative metrics (this setting is relative to the display size).",
  91.         "w:1.000000 h:1.000000", false)
  92.     {}
  93.  
  94.     String    get(const PropertyReceiver* receiver) const;
  95.     void    set(PropertyReceiver* receiver, const String& value);
  96. };
  97.  
  98.  
  99. /*!
  100. \brief
  101.     Property to access minimum window size.
  102.  
  103.     This property offers access to the minimum size setting for the window, using absolute screen pixel metrics.
  104.  
  105.     \par Usage:
  106.         - Name: AbsoluteMinSize
  107.         - Format: "w:[float] h:[float]".
  108.  
  109.     \par Where:
  110.         - w:[float]    specifies the minimum width as a floating point number.
  111.         - h:[float] specifies the minimum height as a floating point number.
  112. */
  113. class AbsoluteMinSize : public Property
  114. {
  115. public:
  116.     AbsoluteMinSize() : Property(
  117.         "AbsoluteMinSize",
  118.         "Property to get/set the minimum size for the Window.  Value is \"w:[float] h:[float]\" using absolute (pixel) metrics.",
  119.         "w:0.000000 h:0.000000", false)
  120.     {}
  121.  
  122.     String    get(const PropertyReceiver* receiver) const;
  123.     void    set(PropertyReceiver* receiver, const String& value);
  124. };
  125.  
  126.  
  127. /*!
  128. \brief
  129.     Property to access maximum window size.
  130.  
  131.     This property offers access to the maximum size setting for the window, using absolute screen pixel metrics.
  132.  
  133.     \par Usage:
  134.         - Name: AbsoluteMaxSize
  135.         - Format: "w:[float] h:[float]".
  136.  
  137.     \par Where:
  138.         - w:[float]    specifies the maximum width as a floating point number.
  139.         - h:[float] specifies the maximum height as a floating point number.
  140. */
  141. class AbsoluteMaxSize : public Property
  142. {
  143. public:
  144.     AbsoluteMaxSize() : Property(
  145.         "AbsoluteMaxSize",
  146.         "Property to get/set the maximum size for the Window.  Value is \"w:[float] h:[float]\" using absolute (pixel) metrics.",
  147.         "", false)
  148.         {}
  149.  
  150.     String    get(const PropertyReceiver* receiver) const;
  151.     void    set(PropertyReceiver* receiver, const String& value);
  152.  
  153.     // default depends upon current size of display.
  154.     bool    isDefault(const PropertyReceiver* receiver) const;
  155.     String    getDefault(const PropertyReceiver* receiver) const;
  156. };
  157.  
  158.  
  159. /*!
  160. \brief
  161.     Property to access the metrics mode setting.
  162.  
  163.     This property offers access to the metrics mode setting for the window.
  164.  
  165.     \par Usage:
  166.         - Name: MetricsMode
  167.         - Format: "[text]".
  168.  
  169.     \par Where [text] is:
  170.         - "Relative" for the relative metrics mode.
  171.         - "Absolute" for the absolute metrics mode.
  172.         - "Inherited" if metrics should be inherited from the parent (only used with set method).
  173. */
  174. class MetricsMode : public Property
  175. {
  176. public:
  177.     MetricsMode() : Property(
  178.         "MetricsMode",
  179.         "Property to get/set the metrics mode for the Window.  Value is \"Relative\", \"Absolute\", or \"Inherited\".",
  180.         "Relative")
  181.     {}
  182.  
  183.     String    get(const PropertyReceiver* receiver) const;
  184.     void    set(PropertyReceiver* receiver, const String& value);
  185. };
  186.  
  187.  
  188. /*!
  189. \brief
  190.     Property to access window ID field.
  191.  
  192.     This property offers access to the client specified ID for the window.
  193.  
  194.     \par Usage:
  195.         - Name: ID
  196.         - Format: "[uint]".
  197.  
  198.     \par Where:
  199.         - [uint] is any unsigned integer value.
  200. */
  201. class ID : public Property
  202. {
  203. public:
  204.     ID() : Property(
  205.         "ID",
  206.         "Property to get/set the ID value of the Window.  Value is an unsigned integer number.",
  207.         "0")
  208.     {}
  209.  
  210.     String    get(const PropertyReceiver* receiver) const;
  211.     void    set(PropertyReceiver* receiver, const String& value);
  212. };
  213.  
  214.  
  215. /*!
  216. \brief
  217.     Property to access window alpha setting.
  218.  
  219.     This property offers access to the alpha-blend setting for the window.
  220.  
  221.     \par Usage:
  222.         - Name: Alpha
  223.         - Format: "[float]".
  224.  
  225.     \par Where:
  226.         - [float] is a floating point number between 0.0 and 1.0.
  227. */
  228. class Alpha : public Property
  229. {
  230. public:
  231.     Alpha() : Property(
  232.         "Alpha",
  233.         "Property to get/set the alpha value of the Window.  Value is floating point number.",
  234.         "1.000000") 
  235.     {}
  236.  
  237.     String    get(const PropertyReceiver* receiver) const;
  238.     void    set(PropertyReceiver* receiver, const String& value);
  239. };
  240.  
  241.  
  242. /*!
  243. \brief
  244.     Property to access window Font setting.
  245.  
  246.     This property offers access to the current Font setting for the window.
  247.  
  248.     \par Usage:
  249.         - Name: Font
  250.         - Format: "[text]".
  251.  
  252.     \par Where:
  253.         - [text] is the name of the Font to assign for this window.  The Font specified must already be loaded.
  254. */
  255. class Font : public Property
  256. {
  257. public:
  258.     Font() : Property(
  259.         "Font",
  260.         "Property to get/set the font for the Window.  Value is the name of the font to use (must be loaded already).",
  261.         "")
  262.     {}
  263.  
  264.     String    get(const PropertyReceiver* receiver) const;
  265.     void    set(PropertyReceiver* receiver, const String& value);
  266.     bool    isDefault(const PropertyReceiver* receiver) const;
  267. };
  268.  
  269.  
  270. /*!
  271. \brief
  272.     Property to access window text setting.
  273.  
  274.     This property offers access to the current text for the window.
  275.  
  276.     \par Usage:
  277.         - Name: Text
  278.         - Format: "[text]".
  279.  
  280.     \par Where:
  281.         - [text] is the name of the Font to assign for this window.  The Font specified must already be loaded.
  282. */
  283. class Text : public Property
  284. {
  285. public:
  286.     Text() : Property(
  287.         "Text", 
  288.         "Property to get/set the text / caption for the Window.  Value is the text string to use.",
  289.         "")
  290.     {}
  291.  
  292.     String    get(const PropertyReceiver* receiver) const;
  293.     void    set(PropertyReceiver* receiver, const String& value);
  294. };
  295.  
  296.  
  297. /*!
  298. \brief
  299.     Property to access window mouse cursor setting.
  300.  
  301.     This property offers access to the current mouse cursor image for the window.
  302.  
  303.     \par Usage:
  304.         - Name: MouseCursorImage
  305.         - Format: "set:[text] image:[text]".
  306.  
  307.     \par Where:
  308.         - set:[text] is the name of the Imageset containing the image.  The Imageset name should not contain spaces.  The Imageset specified must already be loaded.
  309.         - image:[text] is the name of the Image on the specified Imageset.  The Image name should not contain spaces.
  310. */
  311. class MouseCursorImage : public Property
  312. {
  313. public:
  314.     MouseCursorImage() : Property(
  315.         "MouseCursorImage",
  316.         "Property to get/set the mouse cursor image for the Window.  Value should be \"set:<imageset name> image:<image name>\".",
  317.         "")
  318.     {}
  319.  
  320.     String    get(const PropertyReceiver* receiver) const;
  321.     void    set(PropertyReceiver* receiver, const String& value);
  322.     bool    isDefault(const PropertyReceiver* receiver) const;
  323. };
  324.  
  325.  
  326. /*!
  327. \brief
  328.     Property to access window "clipped by parent" setting.
  329.  
  330.     This property offers access to the clipped by parent setting for the window.
  331.  
  332.     \par Usage:
  333.         - Name: ClippedByParent
  334.         - Format: "[text]".
  335.  
  336.     \par Where [Text] is:
  337.         - "True" to indicate the Window is clipped by it's parent.
  338.         - "False" to indicate the Window is not clipped by it's parent.
  339. */
  340. class ClippedByParent : public Property
  341. {
  342. public:
  343.     ClippedByParent() : Property(
  344.         "ClippedByParent",
  345.         "Property to get/set the 'clipped by parent' setting for the Window.  Value is either \"True\" or \"False\".",
  346.         "True")
  347.     {}
  348.  
  349.     String    get(const PropertyReceiver* receiver) const;
  350.     void    set(PropertyReceiver* receiver, const String& value);
  351. };
  352.  
  353.  
  354. /*!
  355. \brief
  356.     Property to access window "Inherits Alpha" setting.
  357.  
  358.     This property offers access to the inherits alpha setting for the window.
  359.  
  360.     \par Usage:
  361.         - Name: InheritsAlpha
  362.         - Format: "[text]".
  363.  
  364.     \par Where [Text] is:
  365.         - "True" to indicate the Window inherits alpha blend values from it's ancestors.
  366.         - "False" to indicate the Window does not inherit alpha blend values from it's ancestors.
  367. */
  368. class InheritsAlpha : public Property
  369. {
  370. public:
  371.     InheritsAlpha() : Property(
  372.         "InheritsAlpha",
  373.         "Property to get/set the 'inherits alpha' setting for the Window.  Value is either \"True\" or \"False\".",
  374.         "True")
  375.     {}
  376.  
  377.     String    get(const PropertyReceiver* receiver) const;
  378.     void    set(PropertyReceiver* receiver, const String& value);
  379. };
  380.  
  381.  
  382. /*!
  383. \brief
  384.     Property to access window "Always-On-Top" setting.
  385.  
  386.     This property offers access to the always on top / topmost setting for the window.
  387.  
  388.     \par Usage:
  389.         - Name: AlwaysOnTop
  390.         - Format: "[text]".
  391.  
  392.     \par Where [Text] is:
  393.         - "True" to indicate the Window is always on top, and appears above all other non-always on top Windows.
  394.         - "False" to indicate the Window is not always on top, and will appear below all other always on top Windows.
  395. */
  396. class AlwaysOnTop : public Property
  397. {
  398. public:
  399.     AlwaysOnTop() : Property(
  400.         "AlwaysOnTop",
  401.         "Property to get/set the 'always on top' setting for the Window.  Value is either \"True\" or \"False\".",
  402.         "False")
  403.     {}
  404.  
  405.     String    get(const PropertyReceiver* receiver) const;
  406.     void    set(PropertyReceiver* receiver, const String& value);
  407. };
  408.  
  409.  
  410. /*!
  411. \brief
  412.     Property to access window Disabled setting.
  413.  
  414.     This property offers access to the enabled / disabled setting for the window.
  415.  
  416.     \par Usage:
  417.         - Name: Disabled
  418.         - Format: "[text]".
  419.  
  420.     \par Where [Text] is:
  421.         - "True" to indicate the Window is disabled, and will normally receive no inputs from the user.
  422.         - "False" to indicate the Window is not disabled and will receive inputs from the user as normal.
  423. */
  424. class Disabled : public Property
  425. {
  426. public:
  427.     Disabled() : Property(
  428.         "Disabled",
  429.         "Property to get/set the 'disabled state' setting for the Window.  Value is either \"True\" or \"False\".",
  430.         "False")
  431.     {}
  432.  
  433.     String    get(const PropertyReceiver* receiver) const;
  434.     void    set(PropertyReceiver* receiver, const String& value);
  435.     bool    isDefault(const PropertyReceiver* receiver) const;
  436. };
  437.  
  438.  
  439. /*!
  440. \brief
  441.     Property to access window Visible setting.
  442.  
  443.     This property offers access to the visible setting for the window.
  444.  
  445.     \par Usage:
  446.         - Name: Visible
  447.         - Format: "[text]".
  448.  
  449.     \par Where [Text] is:
  450.         - "True" to indicate the Window is visible.
  451.         - "False" to indicate the Window is not visible.
  452. */
  453. class Visible : public Property
  454. {
  455. public:
  456.     Visible() : Property(
  457.         "Visible",
  458.         "Property to get/set the 'visible state' setting for the Window.  Value is either \"True\" or \"False\".",
  459.         "True")
  460.     {}
  461.  
  462.     String    get(const PropertyReceiver* receiver) const;
  463.     void    set(PropertyReceiver* receiver, const String& value);
  464.     bool    isDefault(const PropertyReceiver* receiver) const;
  465. };
  466.  
  467.  
  468. /*!
  469. \brief
  470.     Property to access window Restore Old Capture setting.
  471.  
  472.     This property offers access to the restore old capture setting for the window.  This setting is of generally limited use, it
  473.     is primary purpose is for certain operations required for compound widgets.
  474.  
  475.     \par Usage:
  476.         - Name: RestoreOldCapture
  477.         - Format: "[text]".
  478.  
  479.     \par Where [Text] is:
  480.         - "True" to indicate the Window should restore any previous capture Window when it loses input capture.
  481.         - "False" to indicate the Window should not restore the old capture Window.  This is the default behaviour.
  482. */
  483. class RestoreOldCapture : public Property
  484. {
  485. public:
  486.     RestoreOldCapture() : Property(
  487.         "RestoreOldCapture",
  488.         "Property to get/set the 'restore old capture' setting for the Window.  Value is either \"True\" or \"False\".",
  489.         "False")
  490.     {}
  491.  
  492.     String    get(const PropertyReceiver* receiver) const;
  493.     void    set(PropertyReceiver* receiver, const String& value);
  494. };
  495.  
  496.  
  497. /*!
  498. \brief
  499.     Property to access window Destroyed by Parent setting.
  500.  
  501.     This property offers access to the destryed by parent setting for the window.
  502.  
  503.     \par Usage:
  504.         - Name: DestroyedByParent
  505.         - Format: "[text]".
  506.  
  507.     \par Where [Text] is:
  508.         - "True" to indicate the Window should be automatically destroyed when it's parent Window is destroyed.
  509.         - "False" to indicate the Window should not be destroyed when it's parent Window is destroyed.
  510. */
  511. class DestroyedByParent : public Property
  512. {
  513. public:
  514.     DestroyedByParent() : Property(
  515.         "DestroyedByParent",
  516.         "Property to get/set the 'destroyed by parent' setting for the Window.  Value is either \"True\" or \"False\".",
  517.         "True")
  518.     {}
  519.  
  520.     String    get(const PropertyReceiver* receiver) const;
  521.     void    set(PropertyReceiver* receiver, const String& value);
  522. };
  523.  
  524.  
  525. /*!
  526. \brief
  527.     Property to access window width.
  528.  
  529.     This property offers access to the Width setting for the window, using the Windows active metrics mode.
  530.  
  531.     \par Usage:
  532.         - Name: Width
  533.         - Format: "[float]".
  534.  
  535.     \par Where:
  536.         - [float]    specifies the width as a floating point number, using the active metrics system for the Window.
  537. */
  538. class Width : public Property
  539. {
  540. public:
  541.     Width() : Property(
  542.         "Width",
  543.         "Property to get/set the width of the Window.  Value is floating point using the active metrics mode.",
  544.         "0.000000", false) {}
  545.  
  546.     String    get(const PropertyReceiver* receiver) const;
  547.     void    set(PropertyReceiver* receiver, const String& value);
  548. };
  549.  
  550.  
  551. /*!
  552. \brief
  553.     Property to access window width.
  554.  
  555.     This property offers access to the Width setting for the window, using the relative metrics mode.
  556.  
  557.     \par Usage:
  558.         - Name: RelativeWidth
  559.         - Format: "[float]".
  560.  
  561.     \par Where:
  562.         - [float]    specifies the width as a floating point number, using the relative metrics system.
  563. */
  564. class RelativeWidth : public Property
  565. {
  566. public:
  567.     RelativeWidth() : Property(
  568.         "RelativeWidth",
  569.         "Property to get/set the width of the Window.  Value is floating point using relative metrics.",
  570.         "0.000000", false)
  571.     {}
  572.  
  573.     String    get(const PropertyReceiver* receiver) const;
  574.     void    set(PropertyReceiver* receiver, const String& value);
  575. };
  576.  
  577.  
  578. /*!
  579. \brief
  580.     Property to access window width.
  581.  
  582.     This property offers access to the Width setting for the window, using the absolute metrics mode.
  583.  
  584.     \par Usage:
  585.         - Name: AbsoluteWidth
  586.         - Format: "[float]".
  587.  
  588.     \par Where:
  589.         - [float]    specifies the width as a floating point number, using the absolute metrics system.
  590. */
  591. class AbsoluteWidth: public Property
  592. {
  593. public:
  594.     AbsoluteWidth() : Property(
  595.         "AbsoluteWidth",
  596.         "Property to get/set the width of the Window.  Value is floating point using absolute metrics.",
  597.         "0.000000", false)
  598.     {}
  599.  
  600.     String    get(const PropertyReceiver* receiver) const;
  601.     void    set(PropertyReceiver* receiver, const String& value);
  602. };
  603.  
  604.  
  605. /*!
  606. \brief
  607.     Property to access window height.
  608.  
  609.     This property offers access to the Height setting for the window, using the Windows active metrics mode.
  610.  
  611.     \par Usage:
  612.         - Name: Height
  613.         - Format: "[float]".
  614.  
  615.     \par Where:
  616.         - [float]    specifies the height as a floating point number, using the active metrics system for the Window.
  617. */
  618. class Height : public Property
  619. {
  620. public:
  621.     Height() : Property(
  622.         "Height",
  623.         "Property to get/set the height of the Window.  Value is floating point using the active metrics mode.",
  624.         "0.000000", false)
  625.     {}
  626.  
  627.     String    get(const PropertyReceiver* receiver) const;
  628.     void    set(PropertyReceiver* receiver, const String& value);
  629. };
  630.  
  631.  
  632. /*!
  633. \brief
  634.     Property to access window height.
  635.  
  636.     This property offers access to the Height setting for the window, using the relative metrics mode.
  637.  
  638.     \par Usage:
  639.         - Name: RelativeHeight
  640.         - Format: "[float]".
  641.  
  642.     \par Where:
  643.         - [float]    specifies the height as a floating point number, using the relative metrics system.
  644. */
  645. class RelativeHeight : public Property
  646. {
  647. public:
  648.     RelativeHeight() : Property(
  649.         "RelativeHeight",
  650.         "Property to get/set the height of the Window.  Value is floating point using relative metrics.",
  651.         "0.000000", false)
  652.     {}
  653.  
  654.     String    get(const PropertyReceiver* receiver) const;
  655.     void    set(PropertyReceiver* receiver, const String& value);
  656. };
  657.  
  658.  
  659. /*!
  660. \brief
  661.     Property to access window height.
  662.  
  663.     This property offers access to the Height setting for the window, using the absolute metrics mode.
  664.  
  665.     \par Usage:
  666.         - Name: AbsoluteHeight
  667.         - Format: "[float]".
  668.  
  669.     \par Where:
  670.         - [float]    specifies the height as a floating point number, using the absolute metrics system.
  671. */
  672. class AbsoluteHeight : public Property
  673. {
  674. public:
  675.     AbsoluteHeight() : Property(
  676.         "AbsoluteHeight",
  677.         "Property to get/set the height of the Window.  Value is floating point using absolute metrics.",
  678.         "0.000000", false)
  679.     {}
  680.  
  681.     String    get(const PropertyReceiver* receiver) const;
  682.     void    set(PropertyReceiver* receiver, const String& value);
  683. };
  684.  
  685.  
  686. /*!
  687. \brief
  688.     Property to access the window size.
  689.  
  690.     This property offers access to the size setting for the window, using the Windows active metrics mode.
  691.  
  692.     \par Usage:
  693.         - Name: Size
  694.         - Format: "w:[float] h:[float]".
  695.  
  696.     \par Where:
  697.         - w:[float]    specifies the minimum width as a floating point number, using the active metrics system for the Window.
  698.         - h:[float] specifies the minimum height as a floating point number, using the active metrics system for the Window.
  699. */
  700. class Size : public Property
  701. {
  702. public:
  703.     Size() : Property(
  704.         "Size",
  705.         "Property to get/set the size of the Window.  Value is \"w:[float] h:[float]\" using the active metrics mode.",
  706.         "w:0.000000 h:0.000000", false)
  707.     {}
  708.  
  709.     String    get(const PropertyReceiver* receiver) const;
  710.     void    set(PropertyReceiver* receiver, const String& value);
  711. };
  712.  
  713.  
  714. /*!
  715. \brief
  716.     Property to access the window size.
  717.  
  718.     This property offers access to the size setting for the window, using the relative metrics system.
  719.  
  720.     \par Usage:
  721.         - Name: RelativeSize
  722.         - Format: "w:[float] h:[float]".
  723.  
  724.     \par Where:
  725.         - w:[float]    specifies the minimum width as a floating point number, using the relative metrics system.
  726.         - h:[float] specifies the minimum height as a floating point number, using the relative metrics system.
  727. */
  728. class RelativeSize : public Property
  729. {
  730. public:
  731.     RelativeSize() : Property(
  732.         "RelativeSize",
  733.         "Property to get/set the size of the Window.  Value is \"w:[float] h:[float]\" using relative metrics.",
  734.         "w:0.000000 h:0.000000", false)
  735.     {}
  736.  
  737.     String    get(const PropertyReceiver* receiver) const;
  738.     void    set(PropertyReceiver* receiver, const String& value);
  739. };
  740.  
  741.  
  742. /*!
  743. \brief
  744.     Property to access the window size.
  745.  
  746.     This property offers access to the size setting for the window, using the absolute metrics system.
  747.  
  748.     \par Usage:
  749.         - Name: AbsoluteSize
  750.         - Format: "w:[float] h:[float]".
  751.  
  752.     \par Where:
  753.         - w:[float]    specifies the minimum width as a floating point number, using the absolute metrics system.
  754.         - h:[float] specifies the minimum height as a floating point number, using the absolute metrics system.
  755. */
  756. class AbsoluteSize : public Property
  757. {
  758. public:
  759.     AbsoluteSize() : Property(
  760.         "AbsoluteSize",
  761.         "Property to get/set the size of the Window.  Value is \"w:[float] h:[float]\" using absolute metrics.",
  762.         "w:0.000000 h:0.000000", false)
  763.     {}
  764.  
  765.     String    get(const PropertyReceiver* receiver) const;
  766.     void    set(PropertyReceiver* receiver, const String& value);
  767. };
  768.  
  769.  
  770. /*!
  771. \brief
  772.     Property to access window X position.
  773.  
  774.     This property offers access to the X position for the window, using the Windows active metrics mode.
  775.  
  776.     \par Usage:
  777.         - Name: XPosition
  778.         - Format: "[float]".
  779.  
  780.     \par Where:
  781.         - [float]    specifies the x position co-ordinate as a floating point number, using the active metrics system for the Window.
  782. */
  783. class XPosition : public Property
  784. {
  785. public:
  786.     XPosition() : Property(
  787.         "XPosition",
  788.         "Property to get/set the x co-ordinate position of the Window.  Value is a floating point number using the active metrics mode.",
  789.         "0.000000", false)
  790.     {}
  791.  
  792.     String    get(const PropertyReceiver* receiver) const;
  793.     void    set(PropertyReceiver* receiver, const String& value);
  794. };
  795.  
  796.  
  797. /*!
  798. \brief
  799.     Property to access window X position.
  800.  
  801.     This property offers access to the X position for the window, using the relative metrics system.
  802.  
  803.     \par Usage:
  804.         - Name: RelativeXPosition
  805.         - Format: "[float]".
  806.  
  807.     \par Where:
  808.         - [float]    specifies the x position co-ordinate as a floating point number, using the relative metrics system.
  809. */
  810. class RelativeXPosition : public Property
  811. {
  812. public:
  813.     RelativeXPosition() : Property(
  814.         "RelativeXPosition",
  815.         "Property to get/set the x co-ordinate position of the Window.  Value is a floating point number using relative metrics.",
  816.         "0.000000", false)
  817.     {}
  818.  
  819.     String    get(const PropertyReceiver* receiver) const;
  820.     void    set(PropertyReceiver* receiver, const String& value);
  821. };
  822.  
  823.  
  824. /*!
  825. \brief
  826.     Property to access window X position.
  827.  
  828.     This property offers access to the X position for the window, using the absolute metrics system.
  829.  
  830.     \par Usage:
  831.         - Name: AbsoluteXPosition
  832.         - Format: "[float]".
  833.  
  834.     \par Where:
  835.         - [float]    specifies the x position co-ordinate as a floating point number, using the absolute metrics system.
  836. */
  837. class AbsoluteXPosition : public Property
  838. {
  839. public:
  840.     AbsoluteXPosition() : Property(
  841.         "AbsoluteXPosition",
  842.         "Property to get/set the x co-ordinate position of the Window.  Value is a floating point number using absolute metrics.",
  843.         "0.000000", false)
  844.     {}
  845.  
  846.     String    get(const PropertyReceiver* receiver) const;
  847.     void    set(PropertyReceiver* receiver, const String& value);
  848. };
  849.  
  850.  
  851. /*!
  852. \brief
  853.     Property to access window Y position.
  854.  
  855.     This property offers access to the Y position for the window, using the Windows active metrics mode.
  856.  
  857.     \par Usage:
  858.         - Name: YPosition
  859.         - Format: "[float]".
  860.  
  861.     \par Where:
  862.         - [float]    specifies the y position co-ordinate as a floating point number, using the active metrics system for the Window.
  863. */
  864. class YPosition : public Property
  865. {
  866. public:
  867.     YPosition() : Property(
  868.         "YPosition",
  869.         "Property to get/set the y co-ordinate position of the Window.  Value is a floating point number using the active metrics mode.",
  870.         "0.000000", false)
  871.     {}
  872.  
  873.     String    get(const PropertyReceiver* receiver) const;
  874.     void    set(PropertyReceiver* receiver, const String& value);
  875. };
  876.  
  877.  
  878. /*!
  879. \brief
  880.     Property to access window Y position.
  881.  
  882.     This property offers access to the Y position for the window, using the relative metrics system.
  883.  
  884.     \par Usage:
  885.         - Name: RelativeYPosition
  886.         - Format: "[float]".
  887.  
  888.     \par Where:
  889.         - [float]    specifies the y position co-ordinate as a floating point number, using the relative metrics system.
  890. */
  891. class RelativeYPosition : public Property
  892. {
  893. public:
  894.     RelativeYPosition() : Property(
  895.         "RelativeYPosition",
  896.         "Property to get/set the y co-ordinate position of the Window.  Value is a floating point number using relative metrics.",
  897.         "0.000000", false)
  898.     {}
  899.  
  900.     String    get(const PropertyReceiver* receiver) const;
  901.     void    set(PropertyReceiver* receiver, const String& value);
  902. };
  903.  
  904.  
  905. /*!
  906. \brief
  907.     Property to access window Y position.
  908.  
  909.     This property offers access to the Y position for the window, using the absolute metrics system.
  910.  
  911.     \par Usage:
  912.         - Name: AbsoluteYPosition
  913.         - Format: "[float]".
  914.  
  915.     \par Where:
  916.         - [float]    specifies the y position co-ordinate as a floating point number, using the absolute metrics system.
  917. */
  918. class AbsoluteYPosition : public Property
  919. {
  920. public:
  921.     AbsoluteYPosition() : Property(
  922.         "AbsoluteYPosition",
  923.         "Property to get/set the y co-ordinate position of the Window.  Value is a floating point number using absolute metrics.",
  924.         "0.000000", false)
  925.     {}
  926.  
  927.     String    get(const PropertyReceiver* receiver) const;
  928.     void    set(PropertyReceiver* receiver, const String& value);
  929. };
  930.  
  931.  
  932. /*!
  933. \brief
  934.     Property to access window position.
  935.  
  936.     This property offers access to the position for the window, using the Windows active metrics mode.
  937.  
  938.     \par Usage:
  939.         - Name: Position
  940.         - Format: "x:[float] y:[float]".
  941.  
  942.     \par Where:
  943.         - x:[float]    specifies the x position co-ordinate as a floating point number, using the active metrics system for the Window.
  944.         - y:[float]    specifies the y position co-ordinate as a floating point number, using the active metrics system for the Window.
  945. */
  946. class Position : public Property
  947. {
  948. public:
  949.     Position() : Property(
  950.         "Position",
  951.         "Property to get/set the position of the Window.  Value is \"x:[float] y:[float]\" using the active metrics mode.",
  952.         "x:0.000000 y:0.000000", false)
  953.     {}
  954.  
  955.     String    get(const PropertyReceiver* receiver) const;
  956.     void    set(PropertyReceiver* receiver, const String& value);
  957. };
  958.  
  959.  
  960. /*!
  961. \brief
  962.     Property to access window position.
  963.  
  964.     This property offers access to the position for the window, using the relative metrics system.
  965.  
  966.     \par Usage:
  967.         - Name: RelativePosition
  968.         - Format: "x:[float] y:[float]".
  969.  
  970.     \par Where:
  971.         - x:[float]    specifies the x position co-ordinate as a floating point number, using the relative metrics system.
  972.         - y:[float]    specifies the y position co-ordinate as a floating point number, using the relative metrics system.
  973. */
  974. class RelativePosition : public Property
  975. {
  976. public:
  977.     RelativePosition() : Property(
  978.         "RelativePosition",
  979.         "Property to get/set the position of the Window.  Value is \"x:[float] y:[float]\" using relative metrics.",
  980.         "x:0.000000 y:0.000000", false)
  981.     {}
  982.  
  983.     String    get(const PropertyReceiver* receiver) const;
  984.     void    set(PropertyReceiver* receiver, const String& value);
  985. };
  986.  
  987.  
  988. /*!
  989. \brief
  990.     Property to access window position.
  991.  
  992.     This property offers access to the position for the window, using the absolute metrics system.
  993.  
  994.     \par Usage:
  995.         - Name: AbsolutePosition
  996.         - Format: "x:[float] y:[float]".
  997.  
  998.     \par Where:
  999.         - x:[float]    specifies the x position co-ordinate as a floating point number, using the absolute metrics system.
  1000.         - y:[float]    specifies the y position co-ordinate as a floating point number, using the absolute metrics system.
  1001. */
  1002. class AbsolutePosition : public Property
  1003. {
  1004. public:
  1005.     AbsolutePosition() : Property(
  1006.         "AbsolutePosition",
  1007.         "Property to get/set the position of the Window.  Value is \"x:[float] y:[float]\" using absolute metrics.",
  1008.         "x:0.000000 y:0.000000", false)
  1009.     {}
  1010.  
  1011.     String    get(const PropertyReceiver* receiver) const;
  1012.     void    set(PropertyReceiver* receiver, const String& value);
  1013. };
  1014.  
  1015.  
  1016. /*!
  1017. \brief
  1018.     Property to access window area rectangle.
  1019.  
  1020.     This property offers access to the area rectangle (Rect) for the window, using the Windows active metrics mode.
  1021.  
  1022.     \par Usage:
  1023.         - Name: Rect
  1024.         - Format: "l:[float] t:[float] r:[float] b:[float]".
  1025.  
  1026.     \par Where:
  1027.         - l:[float]    specifies the position of the left edge of the area as a floating point number, using the active metrics system for the Window.
  1028.         - t:[float]    specifies the position of the top edge of the area as a floating point number, using the active metrics system for the Window.
  1029.         - r:[float]    specifies the position of the right edge of the area as a floating point number, using the active metrics system for the Window.
  1030.         - b:[float]    specifies the position of the bottom edge of the area as a floating point number, using the active metrics system for the Window.
  1031. */
  1032. class Rect : public Property
  1033. {
  1034. public:
  1035.     Rect() : Property(
  1036.         "Rect",
  1037.         "Property to get/set the area rectangle of the Window.  Value is \"l:[float] t:[float] r:[float] b:[float]\" (where l is left, t is top, r is right, and b is bottom) using the active metrics system.",
  1038.         "l:0.000000 t:0.000000 r:0.000000 b:0.000000", false)
  1039.     {}
  1040.  
  1041.     String    get(const PropertyReceiver* receiver) const;
  1042.     void    set(PropertyReceiver* receiver, const String& value);
  1043. };
  1044.  
  1045.  
  1046. /*!
  1047. \brief
  1048.     Property to access window area rectangle.
  1049.  
  1050.     This property offers access to the area rectangle (Rect) for the window, using the relative metrics system.
  1051.  
  1052.     \par Usage:
  1053.         - Name: RelativeRect
  1054.         - Format: "l:[float] t:[float] r:[float] b:[float]".
  1055.  
  1056.     \par Where:
  1057.         - l:[float]    specifies the position of the left edge of the area as a floating point number, using the relative metrics system.
  1058.         - t:[float]    specifies the position of the top edge of the area as a floating point number, using the relative metrics system.
  1059.         - r:[float]    specifies the position of the right edge of the area as a floating point number, using the relative metrics system.
  1060.         - b:[float]    specifies the position of the bottom edge of the area as a floating point number, using the relative metrics system.
  1061. */
  1062. class RelativeRect : public Property
  1063. {
  1064. public:
  1065.     RelativeRect() : Property(
  1066.         "RelativeRect",
  1067.         "Property to get/set the area rectangle of the Window.  Value is \"l:[float] t:[float] r:[float] b:[float]\" (where l is left, t is top, r is right, and b is bottom) using relative metrics.",
  1068.         "l:0.000000 t:0.000000 r:0.000000 b:0.000000", false) 
  1069.     {}
  1070.  
  1071.     String    get(const PropertyReceiver* receiver) const;
  1072.     void    set(PropertyReceiver* receiver, const String& value);
  1073. };
  1074.  
  1075.  
  1076. /*!
  1077. \brief
  1078.     Property to access window area rectangle.
  1079.  
  1080.     This property offers access to the area rectangle (Rect) for the window, using the absolute metrics system.
  1081.  
  1082.     \par Usage:
  1083.         - Name: AbsoluteRect
  1084.         - Format: "l:[float] t:[float] r:[float] b:[float]".
  1085.  
  1086.     \par Where:
  1087.         - l:[float]    specifies the position of the left edge of the area as a floating point number, using the absolute metrics system.
  1088.         - t:[float]    specifies the position of the top edge of the area as a floating point number, using the absolute metrics system.
  1089.         - r:[float]    specifies the position of the right edge of the area as a floating point number, using the absolute metrics system.
  1090.         - b:[float]    specifies the position of the bottom edge of the area as a floating point number, using the absolute metrics system.
  1091. */
  1092. class AbsoluteRect : public Property
  1093. {
  1094. public:
  1095.     AbsoluteRect() : Property(
  1096.         "AbsoluteRect",
  1097.         "Property to get/set the area rectangle of the Window.  Value is \"l:[float] t:[float] r:[float] b:[float]\" (where l is left, t is top, r is right, and b is bottom) using absolute metrics.",
  1098.         "l:0.000000 t:0.000000 r:0.000000 b:0.000000", false) 
  1099.     {}
  1100.  
  1101.     String    get(const PropertyReceiver* receiver) const;
  1102.     void    set(PropertyReceiver* receiver, const String& value);
  1103. };
  1104.  
  1105.  
  1106. /*!
  1107. \brief
  1108.     Property to access window Z-Order changing enabled setting.
  1109.  
  1110.     This property offers access to the setting that controls whether z-order changes are enabled for the window.
  1111.  
  1112.     \par Usage:
  1113.         - Name: ZOrderChangeEnabled
  1114.         - Format: "[text]".
  1115.  
  1116.     \par Where [Text] is:
  1117.         - "True" to indicate the Window should respect requests to change z-order.
  1118.         - "False" to indicate the Window should not change it's z-order.
  1119. */
  1120. class ZOrderChangeEnabled : public Property
  1121. {
  1122. public:
  1123.     ZOrderChangeEnabled() : Property(
  1124.         "ZOrderChangeEnabled",
  1125.         "Property to get/set the 'z-order changing enabled' setting for the Window.  Value is either \"True\" or \"False\".",
  1126.         "True")
  1127.     {}
  1128.  
  1129.     String    get(const PropertyReceiver* receiver) const;
  1130.     void    set(PropertyReceiver* receiver, const String& value);
  1131. };
  1132.  
  1133.  
  1134. /*!
  1135. \brief
  1136.     Property to control whether the window will receive double/triple-click events.
  1137.  
  1138.     This property offers access to the setting that controls whether a window will receive double-click and
  1139.     triple-click events, or whether the window will receive multiple single mouse button down events instead.
  1140.  
  1141.     \par Usage:
  1142.         - Name: WantsMultiClickEvents
  1143.         - Format: "[text]".
  1144.  
  1145.     \par Where [Text] is:
  1146.         - "True" to indicate the Window wants double-click and triple-click events.
  1147.         - "False" to indicate the Window wants multiple single mouse button down events.
  1148. */
  1149. class WantsMultiClickEvents : public Property
  1150. {
  1151. public:
  1152.     WantsMultiClickEvents() : Property(
  1153.         "WantsMultiClickEvents",
  1154.         "Property to get/set whether the window will receive double-click and triple-click events.  Value is either \"True\" or \"False\".",
  1155.         "True")
  1156.     {}
  1157.  
  1158.     String    get(const PropertyReceiver* receiver) const;
  1159.     void    set(PropertyReceiver* receiver, const String& value);
  1160. };
  1161.  
  1162.  
  1163. /*!
  1164. \brief
  1165.     Property to control whether the window will receive autorepeat mouse button down events.
  1166.  
  1167.     This property offers access to the setting that controls whether a window will receive autorepeat
  1168.     mouse button down events.
  1169.  
  1170.     \par Usage:
  1171.         - Name: MouseButtonDownAutoRepeat
  1172.         - Format: "[text]".
  1173.  
  1174.     \par Where [Text] is:
  1175.         - "True" to indicate the Window will receive autorepeat mouse button down events.
  1176.         - "False" to indicate the Window will not receive autorepeat mouse button down events.
  1177. */
  1178. class MouseButtonDownAutoRepeat : public Property
  1179. {
  1180. public:
  1181.     MouseButtonDownAutoRepeat() : Property(
  1182.         "MouseButtonDownAutoRepeat",
  1183.         "Property to get/set whether the window will receive autorepeat mouse button down events.  Value is either \"True\" or \"False\".",
  1184.         "False")
  1185.     {}
  1186.  
  1187.     String  get(const PropertyReceiver* receiver) const;
  1188.     void    set(PropertyReceiver* receiver, const String& value);
  1189. };
  1190.  
  1191.  
  1192. /*!
  1193. \brief
  1194.     Property to access window autorepeat delay value.
  1195.  
  1196.     This property offers access to the value that controls the initial delay for autorepeat mouse button down events.
  1197.  
  1198.     \par Usage:
  1199.         - Name: AutoRepeatDelay
  1200.         - Format: "[float]".
  1201.  
  1202.     \par Where:
  1203.         - [float]   specifies the delay in seconds.
  1204. */
  1205. class AutoRepeatDelay : public Property
  1206. {
  1207. public:
  1208.     AutoRepeatDelay() : Property(
  1209.         "AutoRepeatDelay",
  1210.         "Property to get/set the autorepeat delay.  Value is a floating point number indicating the delay required in seconds.",
  1211.         "0.300000")
  1212.     {}
  1213.  
  1214.     String  get(const PropertyReceiver* receiver) const;
  1215.     void    set(PropertyReceiver* receiver, const String& value);
  1216. };
  1217.  
  1218.  
  1219. /*!
  1220. \brief
  1221.     Property to access window autorepeat rate value.
  1222.  
  1223.     This property offers access to the value that controls the generation rate for autorepeat mouse button down events.
  1224.  
  1225.     \par Usage:
  1226.         - Name: AutoRepeatRate
  1227.         - Format: "[float]".
  1228.  
  1229.     \par Where:
  1230.         - [float]   specifies the rate at which autorepeat events will be generated in seconds.
  1231. */
  1232. class AutoRepeatRate : public Property
  1233. {
  1234. public:
  1235.     AutoRepeatRate() : Property(
  1236.         "AutoRepeatRate",
  1237.         "Property to get/set the autorepeat rate.  Value is a floating point number indicating the rate required in seconds.",
  1238.         "0.060000")
  1239.     {}
  1240.  
  1241.     String  get(const PropertyReceiver* receiver) const;
  1242.     void    set(PropertyReceiver* receiver, const String& value);
  1243. };
  1244.  
  1245. /*!
  1246. \brief
  1247.     Property to access whether inputs are passed to child windows when
  1248.     input is captured to this window.
  1249.  
  1250.     \par Usage:
  1251.         - Name: DistributeCapturedInputs
  1252.         - Format: "[text]".
  1253.  
  1254.     \par Where [Text] is:
  1255.         - "True" to indicate 'captured' inputs should be passed to attached child windows.
  1256.         - "False" to indicate 'captured' inputs should be passed to this window only.
  1257. */
  1258. class DistributeCapturedInputs : public Property
  1259. {
  1260. public:
  1261.     DistributeCapturedInputs() : Property(
  1262.         "DistributeCapturedInputs",
  1263.         "Property to get/set whether captured inputs are passed to child windows.  Value is either \"True\" or \"False\".",
  1264.         "False")
  1265.     {}
  1266.  
  1267.     String    get(const PropertyReceiver* receiver) const;
  1268.     void    set(PropertyReceiver* receiver, const String& value);
  1269. };
  1270.  
  1271. /*!
  1272. \brief
  1273.     Property to access the custom tooltip for this Window.
  1274.  
  1275.     \par Usage:
  1276.         - Name: CustomTooltipType
  1277.         - Format: "[text]".
  1278.  
  1279.     \par Where:
  1280.         - [Text] is the typename of the custom tooltip for the Window.
  1281.  */
  1282. class CustomTooltipType : public Property
  1283. {
  1284. public:
  1285.     CustomTooltipType() : Property(
  1286.     "CustomTooltipType",
  1287.     "Property to get/set the custom tooltip for the window.  Value is the type name of the custom tooltip.",
  1288.     "")
  1289.     {}
  1290.  
  1291.     String  get(const PropertyReceiver* receiver) const;
  1292.     void    set(PropertyReceiver* receiver, const String& value);
  1293. };
  1294.  
  1295. /*!
  1296. \brief
  1297.     Property to access the tooltip text for this Window.
  1298.  
  1299.     \par Usage:
  1300.         - Name: Tooltip
  1301.         - Format: "[text]".
  1302.  
  1303.     \par Where:
  1304.         - [Text] is the tooltip text for this window.
  1305.  */
  1306. class Tooltip : public Property
  1307. {
  1308. public:
  1309.     Tooltip() : Property(
  1310.     "Tooltip",
  1311.     "Property to get/set the tooltip text for the window.  Value is the tooltip text for the window.",
  1312.     "")
  1313.     {}
  1314.  
  1315.     String  get(const PropertyReceiver* receiver) const;
  1316.     void    set(PropertyReceiver* receiver, const String& value);
  1317. };
  1318.  
  1319. /*!
  1320. \brief
  1321.     Property to access whether the window inherits its tooltip text from its parent whn it has no tooltip text of its own.
  1322.  
  1323.     \par Usage:
  1324.         - Name: InheritsTooltipText
  1325.         - Format: "[text]".
  1326.  
  1327.     \par Where [Text] is:
  1328.         - "True" to indicate the Window inherits its tooltip text from its parent.
  1329.         - "False" to indicate the Window does not inherit its tooltip text.
  1330. */
  1331. class InheritsTooltipText : public Property
  1332. {
  1333. public:
  1334.     InheritsTooltipText() : Property(
  1335.         "InheritsTooltipText",
  1336.         "Property to get/set whether the window inherits its parents tooltip text when it has none of its own.  Value is either \"True\" or \"False\".",
  1337.         "False")
  1338.     {}
  1339.  
  1340.     String  get(const PropertyReceiver* receiver) const;
  1341.     void    set(PropertyReceiver* receiver, const String& value);
  1342. };
  1343.  
  1344.  
  1345. /*!
  1346. \brief
  1347.     Property to access whether the window rises to the top of the z order when clicked.
  1348.  
  1349.     \par Usage:
  1350.         - Name: RiseOnClick
  1351.         - Format: "[text]".
  1352.  
  1353.     \par Where [Text] is:
  1354.         - "True" to indicate the Window will rise to the surface when clicked.
  1355.         - "False" to indicate the Window will not change z position when clicked.
  1356. */
  1357. class RiseOnClick : public Property
  1358. {
  1359. public:
  1360.     RiseOnClick() : Property(
  1361.         "RiseOnClick",
  1362.         "Property to get/set whether the window will come tot he top of the z order hwn clicked.  Value is either \"True\" or \"False\".",
  1363.         "True")
  1364.     {}
  1365.  
  1366.     String    get(const PropertyReceiver* receiver) const;
  1367.     void    set(PropertyReceiver* receiver, const String& value);
  1368. };
  1369.  
  1370.  
  1371. /*!
  1372. \brief
  1373.     Property to access the vertical alignment setting for the window.
  1374.  
  1375.     \par Usage:
  1376.         - Name: VerticalAlignment
  1377.         - Format: "[text]".
  1378.  
  1379.     \par Where [Text] is:
  1380.         - "Top" to indicate the windows position is an offset of its top edge from its parents top edge.
  1381.         - "Centre" to indicate the windows position is an offset of its centre point from its parents centre point.
  1382.         - "Bottom" to indicate the windows position is an offset of its bottom edge from its parents bottom edge.
  1383. */
  1384. class VerticalAlignment : public Property
  1385. {
  1386.     public:
  1387.         VerticalAlignment() : Property(
  1388.         "VerticalAlignment",
  1389.         "Property to get/set the windows vertical alignment.  Value is one of \"Top\", \"Centre\" or \"Bottom\".",
  1390.         "Top")
  1391.         {}
  1392.  
  1393.         String    get(const PropertyReceiver* receiver) const;
  1394.         void    set(PropertyReceiver* receiver, const String& value);
  1395. };
  1396.  
  1397.  
  1398. /*!
  1399. \brief
  1400.     Property to access the horizontal alignment setting for the window.
  1401.  
  1402.     \par Usage:
  1403.         - Name: HorizontalAlignment
  1404.         - Format: "[text]".
  1405.  
  1406.     \par Where [Text] is:
  1407.         - "Left" to indicate the windows position is an offset of its left edge from its parents left edge.
  1408.         - "Centre" to indicate the windows position is an offset of its centre point from its parents centre point.
  1409.         - "Right" to indicate the windows position is an offset of its right edge from its parents right edge.
  1410. */
  1411. class HorizontalAlignment : public Property
  1412. {
  1413.     public:
  1414.         HorizontalAlignment() : Property(
  1415.         "HorizontalAlignment",
  1416.         "Property to get/set the windows horizontal alignment.  Value is one of \"Left\", \"Centre\" or \"Right\".",
  1417.         "Left")
  1418.         {}
  1419.  
  1420.         String    get(const PropertyReceiver* receiver) const;
  1421.         void    set(PropertyReceiver* receiver, const String& value);
  1422. };
  1423.  
  1424.  
  1425. /*
  1426. \brief
  1427.     Property to access the unified area rectangle of the window.
  1428.  
  1429.     \par Usage:
  1430.         - Name: UnifiedAreaRect
  1431.         - Format: "{{[ls],[lo]},{[ts],[to]},{[rs],[ro]},{[bs],[bo]}}"
  1432.  
  1433.     \par Where:
  1434.         - [ls] is a floating point value describing the relative scale value for the left edge.
  1435.         - [lo] is a floating point value describing the absolute offset value for the left edge.
  1436.         - [ts] is a floating point value describing the relative scale value for the top edge.
  1437.         - [to] is a floating point value describing the absolute offset value for the top edge.
  1438.         - [rs] is a floating point value describing the relative scale value for the right edge.
  1439.         - [ro] is a floating point value describing the absolute offset value for the right edge.
  1440.         - [bs] is a floating point value describing the relative scale value for the bottom edge.
  1441.         - [bo] is a floating point value describing the absolute offset value for the bottom edge.
  1442. */
  1443. class UnifiedAreaRect : public Property
  1444. {
  1445.     public:
  1446.         UnifiedAreaRect() : Property(
  1447.         "UnifiedAreaRect",
  1448.         "Property to get/set the windows unified area rectangle.  Value is a \"URect\".",
  1449.         "{{0.000000,0.000000},{0.000000,0.000000},{0.000000,0.000000},{0.000000,0.000000}}")
  1450.         {}
  1451.  
  1452.         String    get(const PropertyReceiver* receiver) const;
  1453.         void    set(PropertyReceiver* receiver, const String& value);
  1454. };
  1455.  
  1456.  
  1457. /*
  1458. \brief
  1459.     Property to access the unified position of the window.
  1460.  
  1461.     \par Usage:
  1462.         - Name: UnifiedPosition
  1463.         - Format: "{{[xs],[xo]},{[ys],[yo]}}"
  1464.  
  1465.     \par Where:
  1466.         - [xs] is a floating point value describing the relative scale value for the position x-coordinate.
  1467.         - [xo] is a floating point value describing the absolute offset value for the position x-coordinate.
  1468.         - [ys] is a floating point value describing the relative scale value for the position y-coordinate.
  1469.         - [yo] is a floating point value describing the absolute offset value for the position y-coordinate.
  1470. */
  1471. class UnifiedPosition : public Property
  1472. {
  1473.     public:
  1474.         UnifiedPosition() : Property(
  1475.         "UnifiedPosition",
  1476.         "Property to get/set the windows unified position.  Value is a \"UVector2\".",
  1477.         "{{0.000000,0.000000},{0.000000,0.000000}}", false)
  1478.         {}
  1479.  
  1480.         String    get(const PropertyReceiver* receiver) const;
  1481.         void    set(PropertyReceiver* receiver, const String& value);
  1482. };
  1483.  
  1484.  
  1485. /*
  1486. \brief
  1487.     Property to access the unified position x-coordinate of the window.
  1488.  
  1489.     \par Usage:
  1490.         - Name: UnifiedXPosition
  1491.         - Format: "{[s],[o]}"
  1492.  
  1493.     \par Where:
  1494.         - [s] is a floating point value describing the relative scale value for the position x-coordinate.
  1495.         - [o] is a floating point value describing the absolute offset value for the position x-coordinate.
  1496. */
  1497. class UnifiedXPosition : public Property
  1498. {
  1499.     public:
  1500.         UnifiedXPosition() : Property(
  1501.         "UnifiedXPosition",
  1502.         "Property to get/set the windows unified position x-coordinate.  Value is a \"UDim\".",
  1503.         "{0.000000,0.000000}", false)
  1504.         {}
  1505.  
  1506.         String    get(const PropertyReceiver* receiver) const;
  1507.         void    set(PropertyReceiver* receiver, const String& value);
  1508. };
  1509.  
  1510.  
  1511. /*
  1512. \brief
  1513.     Property to access the unified position y-coordinate of the window.
  1514.  
  1515.     \par Usage:
  1516.         - Name: UnifiedYPosition
  1517.         - Format: "{[s],[o]}"
  1518.  
  1519.     \par Where:
  1520.         - [s] is a floating point value describing the relative scale value for the position y-coordinate.
  1521.         - [o] is a floating point value describing the absolute offset value for the position y-coordinate.
  1522. */
  1523. class UnifiedYPosition : public Property
  1524. {
  1525.     public:
  1526.         UnifiedYPosition() : Property(
  1527.         "UnifiedYPosition",
  1528.         "Property to get/set the windows unified position y-coordinate.  Value is a \"UDim\".",
  1529.         "{0.000000,0.000000}", false)
  1530.         {}
  1531.  
  1532.         String    get(const PropertyReceiver* receiver) const;
  1533.         void    set(PropertyReceiver* receiver, const String& value);
  1534. };
  1535.  
  1536.  
  1537. /*
  1538. \brief
  1539.     Property to access the unified position of the window.
  1540.  
  1541.     \par Usage:
  1542.         - Name: UnifiedSize
  1543.         - Format: "{{[ws],[wo]},{[hs],[ho]}}"
  1544.  
  1545.     \par Where:
  1546.         - [ws] is a floating point value describing the relative scale value for the width.
  1547.         - [wo] is a floating point value describing the absolute offset value for the width.
  1548.         - [hs] is a floating point value describing the relative scale value for the height.
  1549.         - [ho] is a floating point value describing the absolute offset value for the height.
  1550. */
  1551. class UnifiedSize : public Property
  1552. {
  1553.     public:
  1554.         UnifiedSize() : Property(
  1555.         "UnifiedSize",
  1556.         "Property to get/set the windows unified size.  Value is a \"UVector2\".",
  1557.         "{{0.000000,0.000000},{0.000000,0.000000}}", false)
  1558.         {}
  1559.  
  1560.         String    get(const PropertyReceiver* receiver) const;
  1561.         void    set(PropertyReceiver* receiver, const String& value);
  1562. };
  1563.  
  1564.  
  1565. /*
  1566. \brief
  1567.     Property to access the unified width of the window.
  1568.  
  1569.     \par Usage:
  1570.         - Name: UnifiedWidth
  1571.         - Format: "{[s],[o]}"
  1572.  
  1573.     \par Where:
  1574.         - [s] is a floating point value describing the relative scale value for the width.
  1575.         - [o] is a floating point value describing the absolute offset value for the width.
  1576. */
  1577. class UnifiedWidth : public Property
  1578. {
  1579.     public:
  1580.         UnifiedWidth() : Property(
  1581.         "UnifiedWidth",
  1582.         "Property to get/set the windows unified width.  Value is a \"UDim\".",
  1583.         "{0.000000,0.000000}", false)
  1584.         {}
  1585.  
  1586.         String    get(const PropertyReceiver* receiver) const;
  1587.         void    set(PropertyReceiver* receiver, const String& value);
  1588. };
  1589.  
  1590.  
  1591. /*
  1592. \brief
  1593.     Property to access the unified height of the window.
  1594.  
  1595.     \par Usage:
  1596.         - Name: UnifiedHeight
  1597.         - Format: "{[s],[o]}"
  1598.  
  1599.     \par Where:
  1600.         - [s] is a floating point value describing the relative scale value for the height.
  1601.         - [o] is a floating point value describing the absolute offset value for the height.
  1602. */
  1603. class UnifiedHeight : public Property
  1604. {
  1605.     public:
  1606.         UnifiedHeight() : Property(
  1607.         "UnifiedHeight",
  1608.         "Property to get/set the windows unified height.  Value is a \"UDim\".",
  1609.         "{0.000000,0.000000}", false)
  1610.         {}
  1611.  
  1612.         String    get(const PropertyReceiver* receiver) const;
  1613.         void    set(PropertyReceiver* receiver, const String& value);
  1614. };
  1615.  
  1616.  
  1617. /*
  1618. \brief
  1619.     Property to access the unified minimum size of the window.
  1620.  
  1621.     \par Usage:
  1622.         - Name: UnifiedMinSize
  1623.         - Format: "{{[ws],[wo]},{[hs],[ho]}}"
  1624.  
  1625.     \par Where:
  1626.         - [ws] is a floating point value describing the relative scale value for the minimum width.
  1627.         - [wo] is a floating point value describing the absolute offset value for the minimum width.
  1628.         - [hs] is a floating point value describing the relative scale value for the minimum height.
  1629.         - [ho] is a floating point value describing the absolute offset value for the minimum height.
  1630. */
  1631. class UnifiedMinSize : public Property
  1632. {
  1633.     public:
  1634.         UnifiedMinSize() : Property(
  1635.         "UnifiedMinSize",
  1636.         "Property to get/set the windows unified minimum size.  Value is a \"UVector2\".",
  1637.         "{{0.000000,0.000000},{0.000000,0.000000}}")
  1638.         {}
  1639.  
  1640.         String    get(const PropertyReceiver* receiver) const;
  1641.         void    set(PropertyReceiver* receiver, const String& value);
  1642. };
  1643.  
  1644.  
  1645. /*
  1646. \brief
  1647.     Property to access the unified maximum size of the window.
  1648.  
  1649.     \par Usage:
  1650.         - Name: UnifiedMaxSize
  1651.         - Format: "{{[ws],[wo]},{[hs],[ho]}}"
  1652.  
  1653.     \par Where:
  1654.         - [ws] is a floating point value describing the relative scale value for the maximum width.
  1655.         - [wo] is a floating point value describing the absolute offset value for the maximum width.
  1656.         - [hs] is a floating point value describing the relative scale value for the maximum height.
  1657.         - [ho] is a floating point value describing the absolute offset value for the maximum height.
  1658. */
  1659. class UnifiedMaxSize : public Property
  1660. {
  1661.     public:
  1662.         UnifiedMaxSize() : Property(
  1663.         "UnifiedMaxSize",
  1664.         "Property to get/set the windows unified maximum size.  Value is a \"UVector2\".",
  1665.         "{{0.000000,0.000000},{0.000000,0.000000}}")
  1666.         {}
  1667.  
  1668.         String    get(const PropertyReceiver* receiver) const;
  1669.         void    set(PropertyReceiver* receiver, const String& value);
  1670. };
  1671.  
  1672.  
  1673. } // End of  WindowProperties namespace section
  1674.  
  1675.  
  1676. } // End of  CEGUI namespace section
  1677.  
  1678. #endif    // end of guard _CEGUIWindowProperties_h_
  1679.